00001 /*! \file 00002 * X-Forge Util <br> 00003 * Copyright 2000-2003 Fathammer Ltd 00004 * 00005 * \brief Dynamic array template 00006 * 00007 * $Id: XFuDynamicArray.h,v 1.9 2003/05/08 06:45:33 toni Exp $ 00008 * $Date: 2003/05/08 06:45:33 $ 00009 * $Revision: 1.9 $ 00010 */ 00011 00012 #ifndef XFUDYNAMICARRAY_H_INCLUDED 00013 #define XFUDYNAMICARRAY_H_INCLUDED 00014 00015 00016 //! Default size increment for the element pointer array. 00017 #define XFUDYNAMICARRAY_DEFAULT_SIZE_INCREMENT 10 00018 00019 00020 //! Dynamic array template. 00021 /*! 00022 * Simple usage example to store UINT32's:<br> 00023 * 00024 * \code 00025 * // Create the array 00026 * XFuDynamicArray<UINT32> *store = XFuDynamicArray<UINT32>::create(); 00027 * // put 3 values to the end of the array 00028 * store->put(1); 00029 * store->put(3); 00030 * store->put(4); 00031 * // Insert value in the second position of the array 00032 * store->put(1, 2); 00033 * // store now contains { 1, 2, 3, 4 } 00034 * UINT32 value = store->get(3); 00035 * // value is now 4 00036 * delete store; 00037 * \endcode 00038 */ 00039 template<class T> class XFuDynamicArray 00040 { 00041 protected: 00042 //! The number of elements in the array. 00043 UINT32 mElementCount; 00044 //! Array of elements stored by the dynamic array. 00045 T *mElements; 00046 00047 //! Size increment. 00048 UINT32 mSizeIncrement; 00049 00050 //! The size of the element array. 00051 UINT32 mArraySize; 00052 00053 //! Resizes the element array. 00054 void setArraySize(const UINT32 aSize); 00055 00056 //! Protected constructor. 00057 XFuDynamicArray(); 00058 00059 public: 00060 //! Returns the size increment. 00061 UINT32 getSizeIncrement() const; 00062 //! Sets the size increment. 00063 void setSizeIncrement(const UINT32 aSizeIncrement); 00064 //! Returns the number of elements stored in the array. 00065 UINT32 size() const; 00066 //! Returns the size of the array. 00067 UINT32 maxSize() const; 00068 //! Checks whether the array has any elements. 00069 INT isEmpty() const; 00070 00071 //! Returns an element at the specified position in the array. 00072 T get(const UINT32 aPos) const; 00073 //! Returns the last element from the array. 00074 T get() const; 00075 //! Adds an element to the end of the array. 00076 void put(T aElement); 00077 //! Inserts an element to the array at the specified position. 00078 void put(const UINT32 aPos, T aElement); 00079 //! Removes an element from the array and returns the removed element. 00080 T removeIndex(const UINT32 aPos); 00081 //! Removes an element from the array. 00082 T remove(T aElement); 00083 //! Removes the last element from the array and returns the removed element. 00084 T remove(); 00085 //! Clears the array, but does not free its internal storage. 00086 void clear(); 00087 00088 //! Static constructor. 00089 static XFuDynamicArray * create(const UINT32 aSize = XFUDYNAMICARRAY_DEFAULT_SIZE_INCREMENT); 00090 //! Destructor. 00091 ~XFuDynamicArray(); 00092 }; 00093 00094 00095 template<class T> void XFuDynamicArray<T>::setArraySize(const UINT32 aSize) 00096 { 00097 mElements = (T *)realloc(mElements, aSize * sizeof(T)); 00098 mArraySize = aSize; 00099 } 00100 00101 00102 template<class T> XFuDynamicArray<T>::XFuDynamicArray() 00103 { 00104 mElements = NULL; 00105 mElementCount = 0; 00106 mArraySize = 0; 00107 } 00108 00109 00110 template<class T> UINT32 XFuDynamicArray<T>::getSizeIncrement() const 00111 { 00112 return mSizeIncrement; 00113 } 00114 00115 00116 template<class T> 00117 void XFuDynamicArray<T>::setSizeIncrement(const UINT32 aSizeIncrement) 00118 { 00119 mSizeIncrement = aSizeIncrement; 00120 } 00121 00122 00123 template<class T> UINT32 XFuDynamicArray<T>::size() const 00124 { 00125 return mElementCount; 00126 } 00127 00128 00129 template<class T> UINT32 XFuDynamicArray<T>::maxSize() const 00130 { 00131 return mArraySize; 00132 } 00133 00134 00135 template<class T> INT XFuDynamicArray<T>::isEmpty() const 00136 { 00137 if (mElementCount > 0) 00138 return 0; 00139 else 00140 return 1; 00141 } 00142 00143 00144 template<class T> T XFuDynamicArray<T>::get(const UINT32 aPos) const 00145 { 00146 if (aPos >= mElementCount) 00147 return T(); 00148 else 00149 return mElements[aPos]; 00150 } 00151 00152 00153 template<class T> T XFuDynamicArray<T>::get() const 00154 { 00155 if (mElementCount == 0) 00156 return T(); 00157 else 00158 return mElements[mElementCount - 1]; 00159 } 00160 00161 00162 template<class T> void XFuDynamicArray<T>::put(T aElement) 00163 { 00164 put(mElementCount, aElement); 00165 } 00166 00167 00168 template<class T> void XFuDynamicArray<T>::put(const UINT32 aPos, T aElement) 00169 { 00170 if (aPos > mElementCount) return; 00171 00172 if (mElementCount >= mArraySize) 00173 setArraySize(mArraySize + mSizeIncrement); 00174 00175 if (aPos < mElementCount) 00176 { 00177 UINT32 i; 00178 for (i = mElementCount; i > aPos; --i) 00179 { 00180 mElements[i] = mElements[i - 1]; 00181 } 00182 } 00183 00184 mElements[aPos] = aElement; 00185 00186 mElementCount++; 00187 } 00188 00189 00190 template<class T> T XFuDynamicArray<T>::removeIndex(const UINT32 aPos) 00191 { 00192 if (aPos >= mElementCount) return T(); 00193 00194 T element = mElements[aPos]; 00195 00196 UINT32 i, lastElement; 00197 lastElement = mElementCount - 1; 00198 for (i = aPos; i < lastElement; ++i) 00199 { 00200 mElements[i] = mElements[i + 1]; 00201 } 00202 00203 mElementCount--; 00204 00205 return element; 00206 } 00207 00208 00209 template<class T> T XFuDynamicArray<T>::remove() 00210 { 00211 return removeIndex(mElementCount - 1); 00212 } 00213 00214 00215 template<class T> T XFuDynamicArray<T>::remove(T aElement) 00216 { 00217 UINT32 i; 00218 for (i = 0; i < mElementCount; ++i) 00219 { 00220 if (mElements[i] == aElement) return removeIndex(i); 00221 } 00222 00223 return T(); 00224 } 00225 00226 00227 template<class T> void XFuDynamicArray<T>::clear() 00228 { 00229 mElementCount = 0; 00230 } 00231 00232 00233 template<class T> 00234 XFuDynamicArray<T> * XFuDynamicArray<T>::create(const UINT32 aSize) 00235 { 00236 XFuDynamicArray<T> *xfuda = new XFuDynamicArray<T>(); 00237 if (xfuda == NULL) return NULL; 00238 xfuda->mElements = (T *)malloc(aSize * sizeof(T)); 00239 xfuda->mElementCount = 0; 00240 xfuda->mArraySize = aSize; 00241 xfuda->mSizeIncrement = XFUDYNAMICARRAY_DEFAULT_SIZE_INCREMENT; 00242 00243 return xfuda; 00244 } 00245 00246 00247 template<class T> XFuDynamicArray<T>::~XFuDynamicArray() 00248 { 00249 if (mElements != NULL) 00250 { 00251 free(mElements); 00252 mElements = NULL; 00253 } 00254 } 00255 00256 00257 #endif // !XFUDYNAMICARRAY_H_INCLUDED
![]() | ||||
![]() |
Confidential Copyright © 2002-2003 Fathammer | with doxygen by Dimitri van Heesch |